/**
 * 用户信息管理工具类
 * 提供统一的用户信息获取和管理方法
 */

const { 
  getUserInfo, 
  getToken,
  setUserInfo,
  setToken,
  setUserRoles,
  setUserPermissions
} = require('./storageUtil.js');

const { http } = require('./http.js');

// 存储键名
const ROLES_KEY = 'userRoles';
const PERMISSIONS_KEY = 'userPermissions';

/**
 * 检查用户是否已登录
 * @returns {boolean} 是否登录
 */
function isLogin() {
  return !!getToken();
}

/**
 * 从本地获取用户角色
 * @returns {Array} 用户角色数组
 */
function getUserRoles() {
  try {
    const roles = wx.getStorageSync(ROLES_KEY);
    return roles || [];
  } catch (e) {
    console.error('获取用户角色失败:', e);
    return [];
  }
}

/**
 * 从本地获取用户权限
 * @returns {Array} 用户权限数组
 */
function getUserPermissions() {
  try {
    const permissions = wx.getStorageSync(PERMISSIONS_KEY);
    return permissions || [];
  } catch (e) {
    console.error('获取用户权限失败:', e);
    return [];
  }
}

/**
 * 获取当前用户的完整信息
 * @returns {Object} 用户信息对象
 */
function getCurrentUser() {
  if (!isLogin()) {
    return null;
  }
  
  return {
    userInfo: getUserInfo(),
    token: getToken(),
    roles: getUserRoles(),
    permissions: getUserPermissions(),
    isLoggedIn: true
  };
}

/**
 * 获取用户ID
 * @returns {number|string|null} 用户ID
 */
function getUserId() {
  const userInfo = getUserInfo();
  return userInfo ? (userInfo.userId || userInfo.id) : null;
}

/**
 * 获取用户名
 * @returns {string|null} 用户名
 */
function getUserName() {
  const userInfo = getUserInfo();
  return userInfo ? (userInfo.userName || userInfo.username) : null;
}

/**
 * 检查用户是否有指定角色
 * @param {string|Array} role 角色名称或角色数组
 * @returns {boolean} 是否有该角色
 */
function hasRole(role) {
  const roles = getUserRoles();
  if (!roles || roles.length === 0) return false;
  
  if (Array.isArray(role)) {
    return role.some(r => roles.includes(r));
  }
  
  return roles.includes(role);
}

/**
 * 检查用户是否有指定权限
 * @param {string|Array} permission 权限名称或权限数组
 * @returns {boolean} 是否有该权限
 */
function hasPermission(permission) {
  const permissions = getUserPermissions();
  if (!permissions || permissions.length === 0) return false;
  
  // 如果有超级权限，直接返回true
  if (permissions.includes('*:*:*')) return true;
  
  if (Array.isArray(permission)) {
    return permission.some(p => permissions.includes(p));
  }
  
  return permissions.includes(permission);
}

/**
 * 检查用户是否是管理员
 * @returns {boolean} 是否是管理员
 */
function isAdmin() {
  return hasRole('admin');
}

/**
 * 更新当前用户信息
 * @param {Object} userInfo - 新的用户信息
 */
function updateCurrentUser(userInfo) {
  try {
    if (userInfo) {
      // 更新用户信息
      setUserInfo(userInfo);
      
      // 如果有token，也更新token
      if (userInfo.token) {
        setToken(userInfo.token);
      }
      
      // 如果有角色信息，也更新角色
      if (userInfo.roles) {
        setUserRoles(userInfo.roles);
      }
      
      // 如果有权限信息，也更新权限
      if (userInfo.permissions) {
        setUserPermissions(userInfo.permissions);
      }
      
      console.log('用户信息更新成功:', userInfo);
    }
  } catch (error) {
    console.error('更新用户信息失败:', error);
  }
}

/**
 * 从后端获取最新用户信息
 * @returns {Promise<Object|null>} 返回最新的用户信息或null
 */
async function fetchLatestUserInfo() {
  try {
    if (!isLogin()) {
      console.log('用户未登录，无法获取用户信息');
      return null;
    }

    // 调用后端接口获取用户详细信息
    const res = await http.get('/system/user/profile');
    
    if (res.code === 200 && res.data) {
      const backendUserInfo = res.data;
      
      // 更新本地存储
      updateCurrentUser(backendUserInfo);
      
      console.log('从后端获取到最新用户信息:', backendUserInfo);
      return backendUserInfo;
    } else {
      console.error('后端返回用户信息失败:', res);
      return null;
    }
  } catch (error) {
    console.error('获取最新用户信息失败:', error);
    return null;
  }
}

/**
 * 获取并更新用户信息（如果后端获取失败则返回本地信息）
 * @returns {Promise<Object>} 返回用户信息
 */
async function getAndUpdateUserInfo() {
  try {
    // 先尝试从后端获取最新信息
    const latestInfo = await fetchLatestUserInfo();
    
    if (latestInfo) {
      return latestInfo;
    } else {
      // 如果后端获取失败，返回本地信息
      console.log('后端获取失败，使用本地用户信息');
      return getUserInfo();
    }
  } catch (error) {
    console.error('获取用户信息失败:', error);
    return getUserInfo();
  }
}

/**
 * 强制刷新用户信息
 * @returns {Promise<Object|null>} 返回最新的用户信息或null
 */
async function forceRefreshUserInfo() {
  try {
    const latestInfo = await fetchLatestUserInfo();
    return latestInfo;
  } catch (error) {
    console.error('强制刷新用户信息失败:', error);
    return null;
  }
}

/**
 * 检查token是否过期（供外部调用）
 * @returns {Promise<boolean>} 返回true表示token有效，false表示已过期
 */
async function checkTokenExpiration() {
  try {
    const app = getApp();
    if (app.globalData && app.globalData.tokenService) {
      return await app.globalData.tokenService.manualCheckToken();
    }
    return true; // 如果没有token服务，默认认为有效
  } catch (error) {
    console.error('检查token过期失败:', error);
    return false;
  }
}

/**
 * 获取token状态信息
 * @returns {Object} token状态信息
 */
function getTokenStatus() {
  try {
    const app = getApp();
    if (app.globalData && app.globalData.tokenService) {
      return app.globalData.tokenService.getTokenStatus();
    }
    return { hasToken: false, serviceRunning: false };
  } catch (error) {
    console.error('获取token状态失败:', error);
    return { hasToken: false, serviceRunning: false };
  }
}

module.exports = {
  getCurrentUser,
  getUserId,
  getUserName,
  hasRole,
  hasPermission,
  isAdmin,
  isLogin,
  getUserRoles,
  getUserPermissions,
  updateCurrentUser,
  fetchLatestUserInfo,
  getAndUpdateUserInfo,
  forceRefreshUserInfo,
  checkTokenExpiration,
  getTokenStatus
};
